package com.zds.scm.common.util;

import org.apache.commons.codec.binary.Base64;
import org.apache.log4j.Logger;

import java.io.UnsupportedEncodingException;
import java.net.URLDecoder;
import java.net.URLEncoder;
import java.security.MessageDigest;
import java.text.ParseException;
import java.text.SimpleDateFormat;
import java.util.Date;
import java.util.HashMap;
import java.util.Map;
import java.util.Random;

public class StringUtils {

	private final static String[] hexDigits = { "0", "1", "2", "3", "4", "5", "6", "7", "8", "9", "a", "b", "c", "d", "e", "f" };
	/**
	 * Logger for this class
	 */
	private static final Logger	logger	= Logger.getLogger(StringUtils.class);
	
	/**
	 * 判断传入的字符串是否为空(空或者空格)
	 * @param str
	 * @return true,字符串为空,false字符串不为空
	 */
	public static boolean isNull(String str) {
		return (str == null) || ("".equals(str));
	  
	}
	/**
	 * 判断传入的字符串是否不为空(空或者空格)
	 * @param str
	 * @return true,字符串为空 false字符串不为空,
	 */
	public static boolean isNotNull(String str) {
		return !StringUtils.isNull(str);
	}
	/**
	 * 判断传入的对象是否为空(空或者空格)
	 * @param args
	 * @return true对象不为空,false,对象为空
	 */
	public static boolean isNull(Object args) {
		return (args == null || args.toString().length() == 0);
	}
	/**
	 * 判断传入的对象是否不为空(空或者空格)
	 * @param args
	 * @return true,对象为空，false对象不为空
	 */
	public static boolean isNotNull(Object args) {
		return !StringUtils.isNull(args);
	}
	/**
	 * 日期转换为字符串格式yyyy-MM-dd HH:mm:ss
	 * @param source 待转换的日期
	 * @return 日期转换后的字符串
	 */
	public static String dateTimeToString(Date source){
		SimpleDateFormat formater=new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
		return formater.format(source);		
	}
	/**
	 * 将字符串转换为日期
	 * @param source
	 * @return
	 */
	public static Date stringToDateTime(String source){
		SimpleDateFormat formater=new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
		try {
			return formater.parse(source);
		} catch (ParseException e) {
			e.printStackTrace();
			logger.error("字符串转换为日期错误");
			return null;
		}		
	}
	/**
	 * 将字符串转换为日期
	 * @param source
	 * @return
	 */
	public static Date stringToDate(String source){
		SimpleDateFormat formater=new SimpleDateFormat("yyyy-MM-dd");
		try {
			return formater.parse(source);
		} catch (ParseException e) {
			e.printStackTrace();
			logger.error("字符串转换为日期错误");
			return null;
		}		
	}
	/**
	 * 随机产生指定长度的字符串
	 */
	public static String getRandomString(int length) {
		String str = "abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789";
		Random random = new Random();
		StringBuffer sb = new StringBuffer();

		for (int i = 0; i < length; ++i) {
			int number = random.nextInt(62);

			sb.append(str.charAt(number));
		}

		return sb.toString();
	}

	/**
	 * 判断输入的字符串参数是否为空。
	 * 
	 * @param args 输入的字串
	 * @return true/false
	 */
	public static boolean isNullOrEmpty(String args) {
		if (args == null || args.length() == 0) {
			return true;
		} else {
			return false;
		}
	}

	/**
	 * 判断输入的字符串参数是否为空。
	 * 
	 * @param args 输入的字串
	 * @return true/false
	 */
	public static boolean isNullOrEmpty(Object args) {
		if (args == null || args.toString().length() == 0) {
			return true;
		} else {
			return false;
		}
	}

	/**
	 * 判断输入的字符串参数是否为空或者是"null"字符,如果是,就返回target参数,如果不是,就返回source参数。
	 */
	public static String chanageNull(String source, String target) {
		if (source == null || source.length() == 0 || source.equalsIgnoreCase("null")) {
			return target;
		} else {
			return source;
		}
	}
	/**
	 * 对企业标签逗号的大写替换成小写
	 */
	public static String filterTag(String input) {
		if (null == input) {
			return null;
		}
		if (input.length() == 0) {
			return input;
		}

		if (input.indexOf("，") >= 0) {
			return input.replaceAll("，", ",");
		} else {
			return input;
		}
	}

	// 字符编码处理
	public static String codeToString(String str) { // 处理中文字符串的函数

		String s = str;
		try {
			byte tempB[] = s.getBytes("ISO-8859-1");
			s = new String(tempB);
			return s;
		} catch (Exception e) {
			return s;
		}
	}

	/**
	 * 将null的字符串对象转换成空
	 * 
	 * @param value 转换字对象
	 * @return 转换后字符串
	 */
	public static String null2Empty(Object value) {
		if (value == null) {
			return "";
		} else {
			return value.toString();
		}
	}

	/**
	 * 将逗号分隔的字符串转换成整型数组
	 * 
	 * @param valus 字符串
	 * @return 整型数组
	 */
	public static Integer[] toIntList(String valus) {
		Integer[] intList = null;

		try {
			String[] strList = valus.replace(" ", "").split(",");

			intList = new Integer[strList.length];

			for (int i = 0; i < strList.length; i++) {
				intList[i] = Integer.parseInt(strList[i]);
			}
		} catch (Exception e) {
		}

		return intList;
	}

	/**
	 * 进行Base64编码
	 * 
	 * @param data 待编码字符
	 * @return 编码后字符
	 */
	public static String base64Encode(String data) {
		try {
			return URLEncoder.encode(new String(new Base64().encode(data.getBytes())), "utf-8");
		} catch (UnsupportedEncodingException e) {
			return "";
		}
	}

	/**
	 * 进行Base64解码
	 * 
	 * @param data 待解码字符
	 * @return 解码后字符
	 */
	public static String base64Decode(String data) {
		try {
			return URLDecoder.decode(new String(new Base64().decode(data.getBytes())), "utf-8");
		} catch (UnsupportedEncodingException e) {
			return "";
		}
	}

	/**
	 * md5加密
	 * 
	 * @param origin 待加密字符串
	 * @return 加密后字符串
	 */
	public static String md5(String origin) {
		String resultString = null;

		try {
			resultString = new String(origin);
			MessageDigest md = MessageDigest.getInstance("MD5");
			resultString = byteArrayToHexString(md.digest(resultString.getBytes()));
		} catch (Exception ex) {
		}

		return resultString;
	}

	private static String byteArrayToHexString(byte[] b) {
		StringBuffer resultSb = new StringBuffer();

		for (int i = 0; i < b.length; i++) {
			resultSb.append(byteToHexString(b[i]));
		}

		return resultSb.toString();
	}

	private static String byteToHexString(byte b) {
		int n = b;
		if (n < 0)
			n = 256 + n;
		int d1 = n / 16;
		int d2 = n % 16;

		return hexDigits[d1] + hexDigits[d2];
	}

	/**
	 * 获取URL参数
	 * 
	 * @param url URL
	 * @return URL的参数Map
	 */
	public static Map<String, String> getQueryMap(String url) {
		if (url.indexOf("?") < 0) {
			return null;
		}

		String queryString = url.substring(url.indexOf("?") + 1);
		String[] queryList = queryString.split("&");

		Map<String, String> paramMap = new HashMap<String, String>();

		for (int i = 0; i < queryList.length; i++) {
			String[] paramList = queryList[i].split("=");

			if (paramList.length > 1) {
				paramMap.put(paramList[0], paramList[1]);
			} else {
				paramMap.put(paramList[0], "");
			}
		}

		return paramMap;
	}

	/**
	 * 根据文件名取扩展名
	 * 
	 * @param fileName 文件名
	 * @return 扩展名(.xxx)
	 */
	public static String getExtendName(String fileName) {
		if (StringUtils.isNullOrEmpty(fileName) || fileName.lastIndexOf(".") == -1) {
			return "";
		}

		int lastIndex = fileName.lastIndexOf(".");
		String ext = fileName.substring(lastIndex);

		return ext;
	}

	/**
	 * 从文件路径中取文件名
	 * 
	 * @param fullName 带路径的文件名
	 * @return 文件名
	 */
	public static String getFileName(String fullName) {
		if (StringUtils.isNullOrEmpty(fullName) || fullName.lastIndexOf("/") == -1) {
			return fullName;
		}

		int lastIndex = fullName.lastIndexOf("/");
		String fileName = fullName.substring(lastIndex + 1);

		return fileName;
	}

	/**
	 * 截断字符（页面显示用）
	 * 
	 * @param value 截断前字符
	 * @return 截断后字符
	 */
	public static String getShowTitle(String value) {
		return getShowTitle(value, 14);
	}

	/**
	 * 截断字符（页面显示用）
	 * 
	 * @param value 截断前字符
	 * @param length 保留字符个数（汉字/双字节字符个数）
	 * @return 截断后字符
	 */
	public static String getShowTitle(String value, int length) {
		if (value.getBytes().length < length * 2) {
			return value;
		}

		int count = 0;
		String subString;
		StringBuffer newString = new StringBuffer();

		for (int i = 0; i < value.length(); i++) {
			subString = value.substring(i, i + 1);

			if (subString.getBytes().length < 2) {
				count++;
			} else {
				count += 2;
			}

			if (count > length * 2) {
				break;
			}

			newString.append(subString);
		}

		return newString.toString() + "...";
	}

	/**
	 * 字节长度转成兆
	 * 
	 * @param bLength 字节长度
	 * @return 兆
	 */
	public static String bToMB(int bLength) {
		return bLength / (1024 * 1024) + "M";
	}

	/**
	 * 字符串替换
	 * 
	 * @param source 元字符串
	 * @param oldValue 旧字符串
	 * @param newValue 新字符串
	 * @return 替换后字符串
	 */
	public static String replaceAll(String source, String oldValue, String newValue) {
		StringBuffer buffer = new StringBuffer(source);

		int start = source.indexOf(oldValue);
		int end = start + oldValue.length();

		buffer.replace(start, end, newValue);

		return buffer.toString();
	}
	/**
	 * 判断对象是否为空
	 * 
	 * @param obj
	 *      -参数对象
	 * @return boolean
	 * 		-true:表示对象为空;false:表示对象为非空
	 */
	public static boolean isEmpty(Object obj) {
		return obj == null || obj.toString().equalsIgnoreCase("null") || obj.toString().length() == 0;
	}
	/**
	 * 根据传入的参数生成SQL语句的条件
	 * @param condition
	 * @return
	 */
	public static String generateSecuritySql(Map<String, Object> condition) {
		StringBuffer sb = new StringBuffer(" where");
		//TODO 根据传入的SQL语句生成查询条件
		return sb.toString();
	}
}
